home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / short10.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  49.6 KB  |  1,442 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "short.h"
  9. T0* r199at(T199* C,T0* a1){
  10. T0* R=NULL;
  11. int _foo=0;
  12. _foo=r199has(C,a1);
  13. R=r477item(((T477*)((((T199*)C))->_store/*4*/)),(((T199*)C))->_has_mem/*24*/);
  14. return R;
  15. }
  16. void r199expand(T199* C){
  17. int _old_size=0;
  18. int _i=0;
  19. C->_item_mem=0;
  20. _old_size=r477count(((T477*)((((T199*)C))->_store/*4*/)));
  21. r429resize(((T429*)((((T199*)C))->_chain/*12*/)),1,(2)*(_old_size));
  22. r52resize(((T52*)((((T199*)C))->_keys/*0*/)),1,(2)*(_old_size));
  23. r477resize(((T477*)((((T199*)C))->_store/*4*/)),1,(2)*(_old_size));
  24. _i=(_old_size)+(1);
  25. while (!((_i)==(r429count(((T429*)((((T199*)C))->_chain/*12*/)))))) {
  26. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  27. int b1=(_i)+(1);
  28. int b2=_i;
  29. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  30. }/*]*/
  31. _i=(_i)+(1);
  32. }
  33. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  34. int b1=(((T199*)C))->_free/*16*/;
  35. int b2=_i;
  36. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  37. }/*]*/
  38. C->_free=(_old_size)+(1);
  39. }
  40. /*No:DICTIONARY[RUN_FEATURE,STRING].free*/
  41. void r199make(T199* C){
  42. C->_modulus=(2)*(32);
  43. {T226*n=malloc(sizeof(*n));
  44. *n=M226;
  45. r226make(n,(((T199*)C))->_modulus/*20*/);
  46. C->_buckets=(T0*)n;
  47. }
  48. {T429*n=malloc(sizeof(*n));
  49. *n=M429;
  50. r429make(n,1,32);
  51. C->_chain=(T0*)n;
  52. }
  53. {T477*n=malloc(sizeof(*n));
  54. *n=M477;
  55. r477make(n,1,32);
  56. C->_store=(T0*)n;
  57. }
  58. {T52*n=malloc(sizeof(*n));
  59. *n=M52;
  60. r52make(n,1,32);
  61. C->_keys=(T0*)n;
  62. }
  63. r199initialize(C);
  64. }
  65. void r199resize(T199* C,int a1){
  66. int _p=0;
  67. int _n=0;
  68. int _i=0;
  69. int _hash=0;
  70. r226copy(((T226*)(oBC672tmp_buckets)),(((T199*)C))->_buckets/*8*/);
  71. r226make(((T226*)((((T199*)C))->_buckets/*8*/)),a1);
  72. _i=0;
  73. while (!((_i)>=((((T199*)C))->_modulus/*20*/))) {
  74. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  75. while (!((_n)==(0))) {
  76. _p=r429item(((T429*)((((T199*)C))->_chain/*12*/)),_n);
  77. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T199*)C))->_keys/*0*/)),_n)))))%(a1);
  78. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  79. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  80. int b2=_n;
  81. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  82. }/*]*/
  83. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  84. /*]*/
  85. _n=_p;
  86. }
  87. _i=(_i)+(1);
  88. }
  89. C->_modulus=a1;
  90. C->_item_mem=0;
  91. }
  92. /*No:DICTIONARY[RUN_FEATURE,STRING].item_mem*/
  93. /*No:DICTIONARY[RUN_FEATURE,STRING].chain*/
  94. /*No:DICTIONARY[RUN_FEATURE,STRING].buckets*/
  95. /*No:DICTIONARY[RUN_FEATURE,STRING].keys*/
  96. int r199has(T199* C,T0* a1){
  97. int R=0;
  98. /*IF*/if ((((((T199*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  99. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T199*)C))->_modulus/*20*/)]/*)*/;
  100. while (!((((((T199*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  101. C->_has_mem=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_has_mem/*24*/);
  102. }
  103. }
  104. /*FI*/R=((((T199*)C))->_has_mem/*24*/)!=(0);
  105. return R;
  106. }
  107. /*No:DICTIONARY[RUN_FEATURE,STRING].Min_size*/
  108. /*No:DICTIONARY[RUN_FEATURE,STRING].store*/
  109. void r199with_capacity(T199* C,int a1){
  110. int _i=0;
  111. _i=32;
  112. while (!((_i)>=(a1))) {
  113. _i=(2)*(_i);
  114. }
  115. C->_modulus=(2)*(_i);
  116. {T226*n=malloc(sizeof(*n));
  117. *n=M226;
  118. r226make(n,(((T199*)C))->_modulus/*20*/);
  119. C->_buckets=(T0*)n;
  120. }
  121. {T429*n=malloc(sizeof(*n));
  122. *n=M429;
  123. r429make(n,1,_i);
  124. C->_chain=(T0*)n;
  125. }
  126. {T477*n=malloc(sizeof(*n));
  127. *n=M477;
  128. r477make(n,1,_i);
  129. C->_store=(T0*)n;
  130. }
  131. {T52*n=malloc(sizeof(*n));
  132. *n=M52;
  133. r52make(n,1,_i);
  134. C->_keys=(T0*)n;
  135. }
  136. r199initialize(C);
  137. }
  138. void r199put(T199* C,T0* a1,T0* a2){
  139. int _hash=0;
  140. _hash=(r7hash_code(((T7*)a2)))%((((T199*)C))->_modulus/*20*/);
  141. /*IF*/if ((((((T199*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  142. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  143. while (!((((((T199*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  144. C->_has_mem=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_has_mem/*24*/);
  145. }
  146. /*IF*/if (((((T199*)C))->_has_mem/*24*/)==(0)) {
  147. /*IF*/if (((((T199*)C))->_count/*32*/)>=(r477count(((T477*)((((T199*)C))->_store/*4*/))))) {
  148. r199expand(C);
  149. }
  150. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T199*)C))->_keys/*0*/));
  151. T0* b1=a2;
  152. int b2=(((T199*)C))->_free/*16*/;
  153. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  154. }/*]*/
  155. /*[IRF3.6put*/{T477* C1=((T477*)((((T199*)C))->_store/*4*/));
  156. T0* b1=a1;
  157. int b2=(((T199*)C))->_free/*16*/;
  158. ((((T477*)C1))->_storage/*0*/)[(b2)-((((T477*)C1))->_lower/*12*/)]=(b1);
  159. }/*]*/
  160. C->_has_mem=(((T199*)C))->_free/*16*/;
  161. C->_free=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_free/*16*/);
  162. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  163. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  164. int b2=(((T199*)C))->_has_mem/*24*/;
  165. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  166. }/*]*/
  167. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T199*)C))->_has_mem/*24*/);
  168. /*]*/
  169. C->_count=((((T199*)C))->_count/*32*/)+(1);
  170. /*IF*/if (((((T199*)C))->_count/*32*/)>(((((T199*)C))->_modulus/*20*/)*(2))) {
  171. r199resize(C,(2)*((((T199*)C))->_modulus/*20*/));
  172. }
  173. /*FI*/}
  174. /*FI*/}
  175. else {
  176. /*[IRF3.6put*/{T477* C1=((T477*)((((T199*)C))->_store/*4*/));
  177. T0* b1=a1;
  178. int b2=(((T199*)C))->_has_mem/*24*/;
  179. ((((T477*)C1))->_storage/*0*/)[(b2)-((((T477*)C1))->_lower/*12*/)]=(b1);
  180. }/*]*/
  181. }
  182. /*FI*/C->_item_mem=0;
  183. }
  184. /*No:DICTIONARY[RUN_FEATURE,STRING].modulus*/
  185. /*No:DICTIONARY[RUN_FEATURE,STRING].count*/
  186. /*No:DICTIONARY[RUN_FEATURE,STRING].has_mem*/
  187. void r199initialize(T199* C){
  188. int _i=0;
  189. C->_count=0;
  190. C->_free=1;
  191. C->_has_mem=0;
  192. C->_item_mem=0;
  193. _i=1;
  194. while (!((_i)==(r429count(((T429*)((((T199*)C))->_chain/*12*/)))))) {
  195. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  196. int b1=(_i)+(1);
  197. int b2=_i;
  198. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  199. }/*]*/
  200. _i=(_i)+(1);
  201. }
  202. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  203. int b1=0;
  204. int b2=_i;
  205. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  206. }/*]*/
  207. _i=0;
  208. while (!((_i)>=((((T199*)C))->_modulus/*20*/))) {
  209. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  210. /*]*/
  211. _i=(_i)+(1);
  212. }
  213. }
  214. T0* r718at(T718* C,T0* a1){
  215. T0* R=NULL;
  216. int _foo=0;
  217. _foo=r718has(C,a1);
  218. R=r863item(((T863*)((((T718*)C))->_store/*4*/)),(((T718*)C))->_has_mem/*24*/);
  219. return R;
  220. }
  221. void r718expand(T718* C){
  222. int _old_size=0;
  223. int _i=0;
  224. C->_item_mem=0;
  225. _old_size=r863count(((T863*)((((T718*)C))->_store/*4*/)));
  226. r429resize(((T429*)((((T718*)C))->_chain/*12*/)),1,(2)*(_old_size));
  227. r52resize(((T52*)((((T718*)C))->_keys/*0*/)),1,(2)*(_old_size));
  228. r863resize(((T863*)((((T718*)C))->_store/*4*/)),1,(2)*(_old_size));
  229. _i=(_old_size)+(1);
  230. while (!((_i)==(r429count(((T429*)((((T718*)C))->_chain/*12*/)))))) {
  231. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  232. int b1=(_i)+(1);
  233. int b2=_i;
  234. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  235. }/*]*/
  236. _i=(_i)+(1);
  237. }
  238. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  239. int b1=(((T718*)C))->_free/*16*/;
  240. int b2=_i;
  241. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  242. }/*]*/
  243. C->_free=(_old_size)+(1);
  244. }
  245. /*No:DICTIONARY[BASE_CLASS,STRING].free*/
  246. void r718make(T718* C){
  247. C->_modulus=(2)*(32);
  248. {T226*n=malloc(sizeof(*n));
  249. *n=M226;
  250. r226make(n,(((T718*)C))->_modulus/*20*/);
  251. C->_buckets=(T0*)n;
  252. }
  253. {T429*n=malloc(sizeof(*n));
  254. *n=M429;
  255. r429make(n,1,32);
  256. C->_chain=(T0*)n;
  257. }
  258. {T863*n=malloc(sizeof(*n));
  259. *n=M863;
  260. r863make(n,1,32);
  261. C->_store=(T0*)n;
  262. }
  263. {T52*n=malloc(sizeof(*n));
  264. *n=M52;
  265. r52make(n,1,32);
  266. C->_keys=(T0*)n;
  267. }
  268. r718initialize(C);
  269. }
  270. void r718resize(T718* C,int a1){
  271. int _p=0;
  272. int _n=0;
  273. int _i=0;
  274. int _hash=0;
  275. r226copy(((T226*)(oBC672tmp_buckets)),(((T718*)C))->_buckets/*8*/);
  276. r226make(((T226*)((((T718*)C))->_buckets/*8*/)),a1);
  277. _i=0;
  278. while (!((_i)>=((((T718*)C))->_modulus/*20*/))) {
  279. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  280. while (!((_n)==(0))) {
  281. _p=r429item(((T429*)((((T718*)C))->_chain/*12*/)),_n);
  282. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T718*)C))->_keys/*0*/)),_n)))))%(a1);
  283. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  284. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  285. int b2=_n;
  286. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  287. }/*]*/
  288. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  289. /*]*/
  290. _n=_p;
  291. }
  292. _i=(_i)+(1);
  293. }
  294. C->_modulus=a1;
  295. C->_item_mem=0;
  296. }
  297. /*No:DICTIONARY[BASE_CLASS,STRING].item_mem*/
  298. /*No:DICTIONARY[BASE_CLASS,STRING].chain*/
  299. /*No:DICTIONARY[BASE_CLASS,STRING].keys*/
  300. /*No:DICTIONARY[BASE_CLASS,STRING].buckets*/
  301. int r718has(T718* C,T0* a1){
  302. int R=0;
  303. /*IF*/if ((((((T718*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  304. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T718*)C))->_modulus/*20*/)]/*)*/;
  305. while (!((((((T718*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  306. C->_has_mem=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_has_mem/*24*/);
  307. }
  308. }
  309. /*FI*/R=((((T718*)C))->_has_mem/*24*/)!=(0);
  310. return R;
  311. }
  312. /*No:DICTIONARY[BASE_CLASS,STRING].Min_size*/
  313. /*No:DICTIONARY[BASE_CLASS,STRING].store*/
  314. void r718put(T718* C,T0* a1,T0* a2){
  315. int _hash=0;
  316. _hash=(r7hash_code(((T7*)a2)))%((((T718*)C))->_modulus/*20*/);
  317. /*IF*/if ((((((T718*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  318. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  319. while (!((((((T718*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  320. C->_has_mem=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_has_mem/*24*/);
  321. }
  322. /*IF*/if (((((T718*)C))->_has_mem/*24*/)==(0)) {
  323. /*IF*/if (((((T718*)C))->_count/*32*/)>=(r863count(((T863*)((((T718*)C))->_store/*4*/))))) {
  324. r718expand(C);
  325. }
  326. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T718*)C))->_keys/*0*/));
  327. T0* b1=a2;
  328. int b2=(((T718*)C))->_free/*16*/;
  329. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  330. }/*]*/
  331. /*[IRF3.6put*/{T863* C1=((T863*)((((T718*)C))->_store/*4*/));
  332. T0* b1=a1;
  333. int b2=(((T718*)C))->_free/*16*/;
  334. ((((T863*)C1))->_storage/*0*/)[(b2)-((((T863*)C1))->_lower/*12*/)]=(b1);
  335. }/*]*/
  336. C->_has_mem=(((T718*)C))->_free/*16*/;
  337. C->_free=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_free/*16*/);
  338. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  339. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  340. int b2=(((T718*)C))->_has_mem/*24*/;
  341. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  342. }/*]*/
  343. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T718*)C))->_has_mem/*24*/);
  344. /*]*/
  345. C->_count=((((T718*)C))->_count/*32*/)+(1);
  346. /*IF*/if (((((T718*)C))->_count/*32*/)>(((((T718*)C))->_modulus/*20*/)*(2))) {
  347. r718resize(C,(2)*((((T718*)C))->_modulus/*20*/));
  348. }
  349. /*FI*/}
  350. /*FI*/}
  351. else {
  352. /*[IRF3.6put*/{T863* C1=((T863*)((((T718*)C))->_store/*4*/));
  353. T0* b1=a1;
  354. int b2=(((T718*)C))->_has_mem/*24*/;
  355. ((((T863*)C1))->_storage/*0*/)[(b2)-((((T863*)C1))->_lower/*12*/)]=(b1);
  356. }/*]*/
  357. }
  358. /*FI*/C->_item_mem=0;
  359. }
  360. /*No:DICTIONARY[BASE_CLASS,STRING].modulus*/
  361. /*No:DICTIONARY[BASE_CLASS,STRING].count*/
  362. /*No:DICTIONARY[BASE_CLASS,STRING].has_mem*/
  363. void r718initialize(T718* C){
  364. int _i=0;
  365. C->_count=0;
  366. C->_free=1;
  367. C->_has_mem=0;
  368. C->_item_mem=0;
  369. _i=1;
  370. while (!((_i)==(r429count(((T429*)((((T718*)C))->_chain/*12*/)))))) {
  371. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  372. int b1=(_i)+(1);
  373. int b2=_i;
  374. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  375. }/*]*/
  376. _i=(_i)+(1);
  377. }
  378. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  379. int b1=0;
  380. int b2=_i;
  381. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  382. }/*]*/
  383. _i=0;
  384. while (!((_i)>=((((T718*)C))->_modulus/*20*/))) {
  385. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  386. /*]*/
  387. _i=(_i)+(1);
  388. }
  389. }
  390. /*No:MEMO[COMMENT].item*/
  391. /*No:MEMO[COMMENT].clear*/
  392. /*No:MEMO[COMMENT].set_item*/
  393. T0* r250at(T250* C,T0* a1){
  394. T0* R=NULL;
  395. int _foo=0;
  396. _foo=r250has(C,a1);
  397. R=r396item(((T396*)((((T250*)C))->_store/*4*/)),(((T250*)C))->_has_mem/*24*/);
  398. return R;
  399. }
  400. void r250expand(T250* C){
  401. int _old_size=0;
  402. int _i=0;
  403. C->_item_mem=0;
  404. _old_size=r396count(((T396*)((((T250*)C))->_store/*4*/)));
  405. r429resize(((T429*)((((T250*)C))->_chain/*12*/)),1,(2)*(_old_size));
  406. r52resize(((T52*)((((T250*)C))->_keys/*0*/)),1,(2)*(_old_size));
  407. r396resize(((T396*)((((T250*)C))->_store/*4*/)),1,(2)*(_old_size));
  408. _i=(_old_size)+(1);
  409. while (!((_i)==(r429count(((T429*)((((T250*)C))->_chain/*12*/)))))) {
  410. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  411. int b1=(_i)+(1);
  412. int b2=_i;
  413. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  414. }/*]*/
  415. _i=(_i)+(1);
  416. }
  417. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  418. int b1=(((T250*)C))->_free/*16*/;
  419. int b2=_i;
  420. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  421. }/*]*/
  422. C->_free=(_old_size)+(1);
  423. }
  424. /*No:DICTIONARY[RUN_CLASS,STRING].free*/
  425. void r250make(T250* C){
  426. C->_modulus=(2)*(32);
  427. {T226*n=malloc(sizeof(*n));
  428. *n=M226;
  429. r226make(n,(((T250*)C))->_modulus/*20*/);
  430. C->_buckets=(T0*)n;
  431. }
  432. {T429*n=malloc(sizeof(*n));
  433. *n=M429;
  434. r429make(n,1,32);
  435. C->_chain=(T0*)n;
  436. }
  437. {T396*n=malloc(sizeof(*n));
  438. *n=M396;
  439. r396make(n,1,32);
  440. C->_store=(T0*)n;
  441. }
  442. {T52*n=malloc(sizeof(*n));
  443. *n=M52;
  444. r52make(n,1,32);
  445. C->_keys=(T0*)n;
  446. }
  447. r250initialize(C);
  448. }
  449. T0* r250item(T250* C,int a1){
  450. T0* R=NULL;
  451. /*IF*/if (((((T250*)C))->_item_mem/*28*/)==(0)) {
  452. r250first(C);
  453. while (!((a1)==((((T250*)C))->_item_mem/*28*/))) {
  454. r250forth(C);
  455. }
  456. R=r396item(((T396*)((((T250*)C))->_store/*4*/)),(((T250*)C))->_item_mem_j/*32*/);
  457. }
  458.  else if (((((T250*)C))->_item_mem/*28*/)<=(a1)) {
  459. while (!((a1)==((((T250*)C))->_item_mem/*28*/))) {
  460. r250forth(C);
  461. }
  462. R=r396item(((T396*)((((T250*)C))->_store/*4*/)),(((T250*)C))->_item_mem_j/*32*/);
  463. }
  464. else {
  465. C->_item_mem=0;
  466. R=r250item(C,a1);
  467. }
  468. /*FI*/return R;
  469. }
  470. /*No:DICTIONARY[RUN_CLASS,STRING].item_mem_i*/
  471. void r250resize(T250* C,int a1){
  472. int _p=0;
  473. int _n=0;
  474. int _i=0;
  475. int _hash=0;
  476. r226copy(((T226*)(oBC672tmp_buckets)),(((T250*)C))->_buckets/*8*/);
  477. r226make(((T226*)((((T250*)C))->_buckets/*8*/)),a1);
  478. _i=0;
  479. while (!((_i)>=((((T250*)C))->_modulus/*20*/))) {
  480. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  481. while (!((_n)==(0))) {
  482. _p=r429item(((T429*)((((T250*)C))->_chain/*12*/)),_n);
  483. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T250*)C))->_keys/*0*/)),_n)))))%(a1);
  484. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  485. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  486. int b2=_n;
  487. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  488. }/*]*/
  489. /*[IRF3.5put*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  490. /*]*/
  491. _n=_p;
  492. }
  493. _i=(_i)+(1);
  494. }
  495. C->_modulus=a1;
  496. C->_item_mem=0;
  497. }
  498. /*No:DICTIONARY[RUN_CLASS,STRING].item_mem_j*/
  499. /*No:DICTIONARY[RUN_CLASS,STRING].item_mem*/
  500. /*No:DICTIONARY[RUN_CLASS,STRING].chain*/
  501. /*No:DICTIONARY[RUN_CLASS,STRING].keys*/
  502. /*No:DICTIONARY[RUN_CLASS,STRING].buckets*/
  503. int r250has(T250* C,T0* a1){
  504. int R=0;
  505. /*IF*/if ((((((T250*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  506. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T250*)C))->_modulus/*20*/)]/*)*/;
  507. while (!((((((T250*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  508. C->_has_mem=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_has_mem/*24*/);
  509. }
  510. }
  511. /*FI*/R=((((T250*)C))->_has_mem/*24*/)!=(0);
  512. return R;
  513. }
  514. /*No:DICTIONARY[RUN_CLASS,STRING].Min_size*/
  515. void r250forth(T250* C){
  516. int _i=0;
  517. /*IF*/if ((r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_item_mem_j/*32*/))!=(0)) {
  518. C->_item_mem_j=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_item_mem_j/*32*/);
  519. }
  520. else {
  521. _i=((((T250*)C))->_item_mem_i/*36*/)+(1);
  522. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  523. _i=(_i)+(1);
  524. }
  525. C->_item_mem_i=_i;
  526. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  527. }
  528. /*FI*/C->_item_mem=((((T250*)C))->_item_mem/*28*/)+(1);
  529. }
  530. /*No:DICTIONARY[RUN_CLASS,STRING].store*/
  531. void r250put(T250* C,T0* a1,T0* a2){
  532. int _hash=0;
  533. _hash=(r7hash_code(((T7*)a2)))%((((T250*)C))->_modulus/*20*/);
  534. /*IF*/if ((((((T250*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  535. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  536. while (!((((((T250*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  537. C->_has_mem=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_has_mem/*24*/);
  538. }
  539. /*IF*/if (((((T250*)C))->_has_mem/*24*/)==(0)) {
  540. /*IF*/if (((((T250*)C))->_count/*40*/)>=(r396count(((T396*)((((T250*)C))->_store/*4*/))))) {
  541. r250expand(C);
  542. }
  543. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T250*)C))->_keys/*0*/));
  544. T0* b1=a2;
  545. int b2=(((T250*)C))->_free/*16*/;
  546. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  547. }/*]*/
  548. /*[IRF3.6put*/{T396* C1=((T396*)((((T250*)C))->_store/*4*/));
  549. T0* b1=a1;
  550. int b2=(((T250*)C))->_free/*16*/;
  551. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  552. }/*]*/
  553. C->_has_mem=(((T250*)C))->_free/*16*/;
  554. C->_free=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_free/*16*/);
  555. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  556. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  557. int b2=(((T250*)C))->_has_mem/*24*/;
  558. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  559. }/*]*/
  560. /*[IRF3.5put*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T250*)C))->_has_mem/*24*/);
  561. /*]*/
  562. C->_count=((((T250*)C))->_count/*40*/)+(1);
  563. /*IF*/if (((((T250*)C))->_count/*40*/)>(((((T250*)C))->_modulus/*20*/)*(2))) {
  564. r250resize(C,(2)*((((T250*)C))->_modulus/*20*/));
  565. }
  566. /*FI*/}
  567. /*FI*/}
  568. else {
  569. /*[IRF3.6put*/{T396* C1=((T396*)((((T250*)C))->_store/*4*/));
  570. T0* b1=a1;
  571. int b2=(((T250*)C))->_has_mem/*24*/;
  572. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  573. }/*]*/
  574. }
  575. /*FI*/C->_item_mem=0;
  576. }
  577. /*No:DICTIONARY[RUN_CLASS,STRING].modulus*/
  578. /*No:DICTIONARY[RUN_CLASS,STRING].count*/
  579. /*No:DICTIONARY[RUN_CLASS,STRING].has_mem*/
  580. void r250first(T250* C){
  581. int _i=0;
  582. _i=0;
  583. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  584. _i=(_i)+(1);
  585. }
  586. C->_item_mem_i=_i;
  587. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  588. C->_item_mem=1;
  589. }
  590. void r250initialize(T250* C){
  591. int _i=0;
  592. C->_count=0;
  593. C->_free=1;
  594. C->_has_mem=0;
  595. C->_item_mem=0;
  596. _i=1;
  597. while (!((_i)==(r429count(((T429*)((((T250*)C))->_chain/*12*/)))))) {
  598. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  599. int b1=(_i)+(1);
  600. int b2=_i;
  601. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  602. }/*]*/
  603. _i=(_i)+(1);
  604. }
  605. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  606. int b1=0;
  607. int b2=_i;
  608. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  609. }/*]*/
  610. _i=0;
  611. while (!((_i)>=((((T250*)C))->_modulus/*20*/))) {
  612. /*[IRF3.5put*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  613. /*]*/
  614. _i=(_i)+(1);
  615. }
  616. }
  617. T0* r237at(T237* C,T0* a1){
  618. T0* R=NULL;
  619. int _foo=0;
  620. _foo=r237has(C,a1);
  621. R=r495item(((T495*)((((T237*)C))->_store/*4*/)),(((T237*)C))->_has_mem/*24*/);
  622. return R;
  623. }
  624. void r237expand(T237* C){
  625. int _old_size=0;
  626. int _i=0;
  627. C->_item_mem=0;
  628. _old_size=r495count(((T495*)((((T237*)C))->_store/*4*/)));
  629. r429resize(((T429*)((((T237*)C))->_chain/*12*/)),1,(2)*(_old_size));
  630. r52resize(((T52*)((((T237*)C))->_keys/*0*/)),1,(2)*(_old_size));
  631. r495resize(((T495*)((((T237*)C))->_store/*4*/)),1,(2)*(_old_size));
  632. _i=(_old_size)+(1);
  633. while (!((_i)==(r429count(((T429*)((((T237*)C))->_chain/*12*/)))))) {
  634. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  635. int b1=(_i)+(1);
  636. int b2=_i;
  637. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  638. }/*]*/
  639. _i=(_i)+(1);
  640. }
  641. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  642. int b1=(((T237*)C))->_free/*16*/;
  643. int b2=_i;
  644. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  645. }/*]*/
  646. C->_free=(_old_size)+(1);
  647. }
  648. /*No:DICTIONARY[E_FEATURE,STRING].free*/
  649. void r237resize(T237* C,int a1){
  650. int _p=0;
  651. int _n=0;
  652. int _i=0;
  653. int _hash=0;
  654. r226copy(((T226*)(oBC672tmp_buckets)),(((T237*)C))->_buckets/*8*/);
  655. r226make(((T226*)((((T237*)C))->_buckets/*8*/)),a1);
  656. _i=0;
  657. while (!((_i)>=((((T237*)C))->_modulus/*20*/))) {
  658. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  659. while (!((_n)==(0))) {
  660. _p=r429item(((T429*)((((T237*)C))->_chain/*12*/)),_n);
  661. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T237*)C))->_keys/*0*/)),_n)))))%(a1);
  662. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  663. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  664. int b2=_n;
  665. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  666. }/*]*/
  667. /*[IRF3.5put*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  668. /*]*/
  669. _n=_p;
  670. }
  671. _i=(_i)+(1);
  672. }
  673. C->_modulus=a1;
  674. C->_item_mem=0;
  675. }
  676. /*No:DICTIONARY[E_FEATURE,STRING].item_mem*/
  677. /*No:DICTIONARY[E_FEATURE,STRING].chain*/
  678. /*No:DICTIONARY[E_FEATURE,STRING].buckets*/
  679. /*No:DICTIONARY[E_FEATURE,STRING].keys*/
  680. int r237has(T237* C,T0* a1){
  681. int R=0;
  682. /*IF*/if ((((((T237*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  683. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T237*)C))->_modulus/*20*/)]/*)*/;
  684. while (!((((((T237*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  685. C->_has_mem=r429item(((T429*)((((T237*)C))->_chain/*12*/)),(((T237*)C))->_has_mem/*24*/);
  686. }
  687. }
  688. /*FI*/R=((((T237*)C))->_has_mem/*24*/)!=(0);
  689. return R;
  690. }
  691. /*No:DICTIONARY[E_FEATURE,STRING].Min_size*/
  692. /*No:DICTIONARY[E_FEATURE,STRING].store*/
  693. void r237with_capacity(T237* C,int a1){
  694. int _i=0;
  695. _i=32;
  696. while (!((_i)>=(a1))) {
  697. _i=(2)*(_i);
  698. }
  699. C->_modulus=(2)*(_i);
  700. {T226*n=malloc(sizeof(*n));
  701. *n=M226;
  702. r226make(n,(((T237*)C))->_modulus/*20*/);
  703. C->_buckets=(T0*)n;
  704. }
  705. {T429*n=malloc(sizeof(*n));
  706. *n=M429;
  707. r429make(n,1,_i);
  708. C->_chain=(T0*)n;
  709. }
  710. {T495*n=malloc(sizeof(*n));
  711. *n=M495;
  712. r495make(n,1,_i);
  713. C->_store=(T0*)n;
  714. }
  715. {T52*n=malloc(sizeof(*n));
  716. *n=M52;
  717. r52make(n,1,_i);
  718. C->_keys=(T0*)n;
  719. }
  720. r237initialize(C);
  721. }
  722. void r237put(T237* C,T0* a1,T0* a2){
  723. int _hash=0;
  724. _hash=(r7hash_code(((T7*)a2)))%((((T237*)C))->_modulus/*20*/);
  725. /*IF*/if ((((((T237*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  726. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  727. while (!((((((T237*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  728. C->_has_mem=r429item(((T429*)((((T237*)C))->_chain/*12*/)),(((T237*)C))->_has_mem/*24*/);
  729. }
  730. /*IF*/if (((((T237*)C))->_has_mem/*24*/)==(0)) {
  731. /*IF*/if (((((T237*)C))->_count/*32*/)>=(r495count(((T495*)((((T237*)C))->_store/*4*/))))) {
  732. r237expand(C);
  733. }
  734. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T237*)C))->_keys/*0*/));
  735. T0* b1=a2;
  736. int b2=(((T237*)C))->_free/*16*/;
  737. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  738. }/*]*/
  739. /*[IRF3.6put*/{T495* C1=((T495*)((((T237*)C))->_store/*4*/));
  740. T0* b1=a1;
  741. int b2=(((T237*)C))->_free/*16*/;
  742. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  743. }/*]*/
  744. C->_has_mem=(((T237*)C))->_free/*16*/;
  745. C->_free=r429item(((T429*)((((T237*)C))->_chain/*12*/)),(((T237*)C))->_free/*16*/);
  746. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  747. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  748. int b2=(((T237*)C))->_has_mem/*24*/;
  749. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  750. }/*]*/
  751. /*[IRF3.5put*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T237*)C))->_has_mem/*24*/);
  752. /*]*/
  753. C->_count=((((T237*)C))->_count/*32*/)+(1);
  754. /*IF*/if (((((T237*)C))->_count/*32*/)>(((((T237*)C))->_modulus/*20*/)*(2))) {
  755. r237resize(C,(2)*((((T237*)C))->_modulus/*20*/));
  756. }
  757. /*FI*/}
  758. /*FI*/}
  759. else {
  760. /*[IRF3.6put*/{T495* C1=((T495*)((((T237*)C))->_store/*4*/));
  761. T0* b1=a1;
  762. int b2=(((T237*)C))->_has_mem/*24*/;
  763. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  764. }/*]*/
  765. }
  766. /*FI*/C->_item_mem=0;
  767. }
  768. /*No:DICTIONARY[E_FEATURE,STRING].modulus*/
  769. /*No:DICTIONARY[E_FEATURE,STRING].count*/
  770. /*No:DICTIONARY[E_FEATURE,STRING].has_mem*/
  771. void r237initialize(T237* C){
  772. int _i=0;
  773. C->_count=0;
  774. C->_free=1;
  775. C->_has_mem=0;
  776. C->_item_mem=0;
  777. _i=1;
  778. while (!((_i)==(r429count(((T429*)((((T237*)C))->_chain/*12*/)))))) {
  779. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  780. int b1=(_i)+(1);
  781. int b2=_i;
  782. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  783. }/*]*/
  784. _i=(_i)+(1);
  785. }
  786. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  787. int b1=0;
  788. int b2=_i;
  789. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  790. }/*]*/
  791. _i=0;
  792. while (!((_i)>=((((T237*)C))->_modulus/*20*/))) {
  793. /*[IRF3.5put*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  794. /*]*/
  795. _i=(_i)+(1);
  796. }
  797. }
  798. T0*oBC364eh=NULL;
  799. void r376check_creation_clause(T376* C,T0* a1){
  800. /*IF*/if (/*(IRF4.7has_creation_clause*/((((T605*)((T605*)(X291base_class(a1)))))->_creation_clause_list/*44*/)!=(NULL)/*)*/) {
  801. /*[IRF3.6append*/{T0* b1=((T0*)ms1_334);
  802. r7append(((T7*)(oBC683explanation)),b1);
  803. }/*]*/
  804. r683add_type(a1,((T0*)ms2_334));
  805. r376error((((T376*)C))->_start_position/*8*/,((T0*)ms3_334));
  806. }
  807. /*FI*/}
  808. T0* r376add_comment(T376* C,T0* a1){
  809. T0* R=NULL;
  810. /*IF*/if (((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r52count(((T52*)((((T393*)((T393*)a1)))->_list/*4*/)))/*)*/)==(0))) {
  811. R=(T0*)C;
  812. }
  813. /*AF*/else {
  814. {T59*n=malloc(sizeof(*n));
  815. *n=M59;
  816. r59make(n,(T0*)C,a1);
  817. R=(T0*)n;
  818. }
  819. }
  820. /*FI*/return R;
  821. }
  822. void r376check_created_type(T376* C,T0* a1){
  823. T0* _rt=NULL;
  824. _rt=X291run_type(a1);
  825. /*IF*/if ((((T604*)((T604*)(oBC364small_eiffel))))->_short_flag/*4*/) {
  826. }
  827.  else if ((((T605*)((T605*)(X291base_class(_rt)))))->_is_deferred/*16*/) {
  828. r683add_type(_rt,((T0*)ms2_747));
  829. r683add_position((((T376*)C))->_start_position/*8*/);
  830. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms3_747);
  831. r683fatal_error(((T683*)(oBC364eh)),b1);
  832. }/*]*/
  833. }
  834. /*FI*//*IF*/if (X291is_formal_generic(a1)) {
  835. r683add_position((((T376*)C))->_start_position/*8*/);
  836. /*[IRF3.6append*/{T0* b1=((T0*)ms4_747);
  837. r7append(((T7*)(oBC683explanation)),b1);
  838. }/*]*/
  839. r683add_type(a1,((T0*)ms5_747));
  840. r683print_as_fatal_error(((T683*)(oBC364eh)));
  841. }
  842. /*FI*/r368set_at_run_time(((T368*)(X291run_class(_rt))));
  843. }
  844. /*No:CREATION_CALL_2.writable*/
  845. void r376make(T376* C,T0* a1,T0* a2,T0* a3){
  846. C->_start_position=a1;
  847. C->_type=a2;
  848. C->_writable=a3;
  849. }
  850. /*No:CREATION_CALL_2.type*/
  851. /*No:CREATION_CALL_2.start_position*/
  852. T0* r376to_runnable(T376* C,T0* a1){
  853. T0* R=NULL;
  854. /*IF*/if (((((T376*)C))->_run_compound/*4*/)==((void*)(NULL))) {
  855. r376check_writable(C,a1);
  856. r376check_explicit_type(C);
  857. r376check_created_type(C,(((T376*)C))->_type/*16*/);
  858. r376check_creation_clause(C,(((T376*)C))->_type/*16*/);
  859. R=(T0*)C;
  860. }
  861. else {
  862. {T376*n=malloc(sizeof(*n));
  863. *n=M376;
  864. r376make(n,(((T376*)C))->_start_position/*8*/,(((T376*)C))->_type/*16*/,(((T376*)C))->_writable/*12*/);
  865. R=(T0*)n;
  866. }
  867. R=r376to_runnable(((T376*)R),a1);
  868. }
  869. /*FI*/return R;
  870. }
  871. T0* r376current_type(T376* C){
  872. T0* R=NULL;
  873. /*IF*/if (((((T376*)C))->_run_compound/*4*/)!=((void*)(NULL))) {
  874. R=(((T592*)((T592*)((((T376*)C))->_run_compound/*4*/))))->_current_type/*4*/;
  875. }
  876. /*FI*/return R;
  877. }
  878. T0*oBC364small_eiffel=NULL;
  879. /*No:CREATION_CALL_2.run_compound*/
  880. void r376check_explicit_type(T376* C){
  881. T0* _t=NULL;
  882. _t=X291to_runnable((((T376*)C))->_type/*16*/,r376current_type(C));
  883. /*IF*/if (((_t)==((void*)(NULL)))||(!(X291is_run_type(_t)))) {
  884. r683add_position(X291start_position((((T376*)C))->_type/*16*/));
  885. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms1_432);
  886. r683fatal_error(((T683*)(oBC364eh)),b1);
  887. }/*]*/
  888. }
  889. else {
  890. C->_type=_t;
  891. }
  892. /*FI*//*IF*/if (!(X291is_a((((T376*)C))->_type/*16*/,X662result_type((((T376*)C))->_writable/*12*/)))) {
  893. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms2_432);
  894. r683fatal_error(((T683*)(oBC364eh)),b1);
  895. }/*]*/
  896. }
  897. /*FI*/}
  898. void r376check_writable(T376* C,T0* a1){
  899. T0* _w=NULL;
  900. C->_run_compound=a1;
  901. _w=X662to_runnable((((T376*)C))->_writable/*12*/,r376current_type(C));
  902. /*IF*/if ((_w)==((void*)(NULL))) {
  903. r683add_position(X662start_position((((T376*)C))->_writable/*12*/));
  904. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms1_747);
  905. r683fatal_error(((T683*)(oBC364eh)),b1);
  906. }/*]*/
  907. }
  908. else {
  909. C->_writable=_w;
  910. }
  911. /*FI*/}
  912. void r376error(T0* a1,T0* a2){
  913. r683add_position(a1);
  914. r683error(((T683*)(oBC364eh)),a2);
  915. }
  916. /*No:CREATION_CALL_2.fatal_error*/
  917. /*No:CREATION_CALL_2.end_mark_comment*/
  918. void r343short(T343* C,T0* a1,T0* a2){
  919. int _i=0;
  920. r580hook_or(((T580*)(oBC364short_print)),a1,a2);
  921. /*IF*/if (((((T343*)C))->_header_comment/*4*/)==((void*)(NULL))) {
  922. r580hook_or(((T580*)(oBC364short_print)),((T0*)ms3_343),((T0*)ms4_343));
  923. }
  924. else {
  925. r580hook_or(((T580*)(oBC364short_print)),((T0*)ms5_343),((T0*)ms6_343));
  926. r393short(((T393*)((((T343*)C))->_header_comment/*4*/)),((T0*)ms7_343),((T0*)ms8_343),((T0*)ms9_343),((T0*)ms10_343));
  927. r580hook_or(((T580*)(oBC364short_print)),((T0*)ms11_343),((T0*)ms12_343));
  928. }
  929. /*FI*//*IF*/if (((((T343*)C))->_list/*8*/)==((void*)(NULL))) {
  930. r580hook_or(((T580*)(oBC364short_print)),((T0*)ms13_343),((T0*)ms14_343));
  931. }
  932. else {
  933. r580hook_or(((T580*)(oBC364short_print)),((T0*)ms15_343),((T0*)ms16_343));
  934. _i=1;
  935. while (!((_i)==((((T608*)((T608*)((((T343*)C))->_list/*8*/))))->_upper/*8*/))) {
  936. r348short(((T348*)(r608item(((T608*)((((T343*)C))->_list/*8*/)),_i))),((T0*)ms17_343),((T0*)ms18_343),((T0*)ms19_343),((T0*)ms20_343),((T0*)ms21_343),((T0*)ms22_343),((T0*)ms23_343),((T0*)ms24_343),((T0*)ms25_343),((T0*)ms26_343),((T0*)ms27_343),((T0*)ms28_343),((T0*)ms29_343),((T0*)ms30_343),((T0*)ms31_343),((T0*)ms32_343),((T0*)ms33_343),((T0*)ms34_343),((T0*)ms35_343),((T0*)ms36_343),((T0*)ms37_343),((T0*)ms38_343),((T0*)ms39_343),((T0*)ms40_343),((T0*)ms41_343),((T0*)ms42_343));
  937. _i=(_i)+(1);
  938. }
  939. r348short(((T348*)(r608item(((T608*)((((T343*)C))->_list/*8*/)),_i))),((T0*)ms43_343),((T0*)ms44_343),((T0*)ms45_343),((T0*)ms46_343),((T0*)ms47_343),((T0*)ms48_343),((T0*)ms49_343),((T0*)ms50_343),((T0*)ms51_343),((T0*)ms52_343),((T0*)ms53_343),((T0*)ms54_343),((T0*)ms55_343),((T0*)ms56_343),((T0*)ms57_343),((T0*)ms58_343),((T0*)ms59_343),((T0*)ms60_343),((T0*)ms61_343),((T0*)ms62_343),((T0*)ms63_343),((T0*)ms64_343),((T0*)ms65_343),((T0*)ms66_343),((T0*)ms67_343),((T0*)ms68_343));
  940. r580hook_or(((T580*)(oBC364short_print)),((T0*)ms69_343),((T0*)ms70_343));
  941. }
  942. /*FI*/r580hook_or(((T580*)(oBC364short_print)),((T0*)ms71_343),((T0*)ms72_343));
  943. }
  944. /*No:E_REQUIRE.is_require_else*/
  945. /*No:E_REQUIRE.empty*/
  946. void r343from_runnable(T343* C,T0* a1){
  947. C->_list=a1;
  948. C->_current_type=(((T348*)((T348*)(r608item(((T608*)((((T343*)C))->_list/*8*/)),1)))))->_current_type/*12*/;
  949. }
  950. T0*oBC364short_print=NULL;
  951. void r343make(T343* C,T0* a1,T0* a2,T0* a3){
  952. C->_start_position=a1;
  953. C->_header_comment=a2;
  954. C->_list=a3;
  955. }
  956. /*No:E_REQUIRE.set_header_comment*/
  957. /*No:E_REQUIRE.start_position*/
  958. /*No:E_REQUIRE.list*/
  959. /*No:E_REQUIRE.current_type*/
  960. /*No:E_REQUIRE.header_comment*/
  961. /*No:E_REQUIRE.set_require_else*/
  962. /*No:INFIX_NAME.short*/
  963. T0*oBC364unique_string=NULL;
  964. /*No:INFIX_NAME.set_is_frozen*/
  965. void r454make(T454* C,T0* a1,T0* a2){
  966. C->_to_string=r902item(a1);
  967. C->_start_position=a2;
  968. C->_to_key=r902for_infix((((T454*)C))->_to_string/*4*/);
  969. }
  970. /*No:INFIX_NAME.to_string*/
  971. /*No:INFIX_NAME.start_position*/
  972. /*No:INFIX_NAME.to_key*/
  973. /*No:INFIX_NAME.is_frozen*/
  974. void r454undefine_in(T454* C,T0* a1){
  975. /*IF*/if ((((T454*)C))->_is_frozen/*12*/) {
  976. r454error((((T454*)C))->_start_position/*8*/,((T0*)ms1_776));
  977. r605fatal_undefine(((T605*)a1),(T0*)C);
  978. }
  979. /*FI*/}
  980. void r454error(T0* a1,T0* a2){
  981. r683add_position(a1);
  982. r683error(((T683*)(oBC364eh)),a2);
  983. }
  984. T0* r454origin_base_class(T454* C){
  985. T0* R=NULL;
  986. T0* _sp=NULL;
  987. _sp=(((T454*)C))->_start_position/*8*/;
  988. /*IF*/if ((_sp)!=((void*)(NULL))) {
  989. R=r627base_class(((T627*)_sp));
  990. }
  991. /*FI*/return R;
  992. }
  993. /*No:ONCE_PROCEDURE.arguments*/
  994. T0* r134try_to_undefine(T134* C,T0* a1,T0* a2){
  995. T0* R=NULL;
  996. X776undefine_in(a1,a2);
  997. R=r134try_to_undefine_aux(C,a1,a2);
  998. /*IF*/if ((R)!=((void*)(NULL))) {
  999. /*X249*//*[IRF3.3set_clients*/((((T853*)(((T853*)R))))->_clients)=((((T134*)C))->_clients/*24*/);
  1000. /*]*/
  1001. }
  1002. else {
  1003. r605fatal_undefine(((T605*)a2),a1);
  1004. }
  1005. /*FI*/return R;
  1006. }
  1007. T0*oBC359assertion_collector=NULL;
  1008. /*No:ONCE_PROCEDURE.is_deferred*/
  1009. /*No:ONCE_PROCEDURE.fz_bad_assertion*/
  1010. T0* r134runnable(T0* a1,T0* a2,T0* a3){
  1011. T0* R=NULL;
  1012. T0* _a=NULL;
  1013. int _i=0;
  1014. /*IF*/if (!(r608empty(((T608*)a1)))) {
  1015. R=r608twin(((T608*)a1));
  1016. _i=(((T608*)((T608*)R)))->_upper/*8*/;
  1017. while (!((_i)==(0))) {
  1018. r604push(((T604*)(oBC364small_eiffel)),a3);
  1019. _a=r348to_runnable(((T348*)(r608item(((T608*)R),_i))),a2);
  1020. /*IF*/if ((_a)==((void*)(NULL))) {
  1021. r134error(r348start_position(((T348*)(r608item(((T608*)R),_i)))),((T0*)ms57_470));
  1022. }
  1023. else {
  1024. /*[IRF3.6put*/{T608* C1=((T608*)R);
  1025. T0* b1=_a;
  1026. int b2=_i;
  1027. ((((T608*)C1))->_storage/*0*/)[(b2)-((((T608*)C1))->_lower/*12*/)]=(b1);
  1028. }/*]*/
  1029. }
  1030. /*FI*/r604pop(((T604*)(oBC364small_eiffel)));
  1031. _i=(_i)-(1);
  1032. }
  1033. }
  1034. /*FI*/return R;
  1035. }
  1036. /*No:ONCE_PROCEDURE.rescue_compound*/
  1037. void r134add_into(T134* C,T0* a1){
  1038. T0* _fn=NULL;
  1039. int _i=0;
  1040. C->_base_class=r627base_class(((T627*)(X776start_position(/*(IRF4.6item*/r855item(((T855*)((((T953*)((T953*)((((T134*)C))->_names/*8*/))))->_list/*0*/)),1)/*)*/))));
  1041. _i=1;
  1042. while (!((_i)>(/*(IRF4.6count*/(((T855*)((T855*)((((T953*)((T953*)((((T134*)C))->_names/*8*/))))->_list/*0*/))))->_upper/*8*//*)*/))) {
  1043. _fn=/*(IRF4.6item*/r855item(((T855*)((((T953*)((T953*)((((T134*)C))->_names/*8*/))))->_list/*0*/)),_i)/*)*/;
  1044. /*IF*/if (r237has(((T237*)a1),X776to_key(_fn))) {
  1045. _fn=/*X359*/((T0*)/*(IRF4.6first_name*//*(IRF4.6item*/r855item(((T855*)((((T953*)((T953*)((((T398*)((T398*)(r237at(((T237*)a1),X776to_key(_fn))))))->_names/*8*/))))->_list/*0*/)),1)/*)*//*)*/);
  1046. r683add_position(X776start_position(_fn));
  1047. r683add_position(X776start_position(/*(IRF4.6item*/r855item(((T855*)((((T953*)((T953*)((((T134*)C))->_names/*8*/))))->_list/*0*/)),_i)/*)*/));
  1048. r683error(((T683*)(oBC364eh)),((T0*)ms11_359));
  1049. /*[IRF3.6append*/{T0* b1=X776to_string(_fn);
  1050. r7append(((T7*)(oBC683explanation)),b1);
  1051. }/*]*/
  1052. r683error(((T683*)(oBC364eh)),((T0*)ms67_470));
  1053. }
  1054. else {
  1055. r237put(((T237*)a1),(T0*)C,X776to_key(_fn));
  1056. }
  1057. /*FI*/_i=(_i)+(1);
  1058. }
  1059. }
  1060. /*No:ONCE_PROCEDURE.end_comment*/
  1061. T0*oBC359header_comment_memory=NULL;
  1062. T0* r134try_to_undefine_aux(T134* C,T0* a1,T0* a2){
  1063. T0* R=NULL;
  1064. {T853*n=malloc(sizeof(*n));
  1065. *n=M853;
  1066. r853from_effective(n,a1,(((T134*)C))->_arguments/*28*/,(((T134*)C))->_require_assertion/*36*/,(((T134*)C))->_ensure_assertion/*40*/,a2);
  1067. R=(T0*)n;
  1068. }
  1069. return R;
  1070. }
  1071. void r134make(T134* C,T0* a1,T0* a2,T0* a3,T0* a4,T0* a5,T0* a6,T0* a7){
  1072. r134make_routine(C,a1,a2,a3,a4,a5);
  1073. C->_local_vars=a6;
  1074. C->_routine_body=a7;
  1075. C->_use_current_state=1011;
  1076. }
  1077. /*No:ONCE_PROCEDURE.not_computed*/
  1078. /*No:ONCE_PROCEDURE.nb_errors*/
  1079. void r134make_routine(T134* C,T0* a1,T0* a2,T0* a3,T0* a4,T0* a5){
  1080. r134make_e_feature(C,a1,NULL);
  1081. C->_header_comment=a4;
  1082. C->_arguments=a2;
  1083. C->_obsolete_mark=a3;
  1084. C->_require_assertion=a5;
  1085. }
  1086. /*No:ONCE_PROCEDURE.local_vars*/
  1087. void r134set_header_comment(T134* C,T0* a1){
  1088. /*IF*/if (((a1)!=((void*)(NULL)))&&((/*(IRF4.6count*/r52count(((T52*)((((T393*)((T393*)a1)))->_list/*4*/)))/*)*/)>(1))) {
  1089. C->_end_comment=a1;
  1090. }
  1091. /*FI*/}
  1092. T0* r134start_position(T134* C){
  1093. T0* R=NULL;
  1094. R=X776start_position(/*(IRF4.6first_name*//*(IRF4.6item*/r855item(((T855*)((((T953*)((T953*)((((T134*)C))->_names/*8*/))))->_list/*0*/)),1)/*)*//*)*/);
  1095. return R;
  1096. }
  1097. T0* r134to_run_feature(T134* C,T0* a1,T0* a2){
  1098. T0* R=NULL;
  1099. r134check_obsolete(C);
  1100. {T869*n=malloc(sizeof(*n));
  1101. *n=M869;
  1102. r869make(n,a1,a2,(T0*)C);
  1103. R=(T0*)n;
  1104. }
  1105. return R;
  1106. }
  1107. /*No:ONCE_PROCEDURE.ensure_assertion*/
  1108. /*No:ONCE_PROCEDURE.code_require*/
  1109. T0* r134run_ensure(T0* a1){
  1110. T0* R=NULL;
  1111. T0* _r=NULL;
  1112. r608clear(((T608*)(oBC359assertion_collector)));
  1113. /*[IRF3.3clear*/{T0* _default_item=NULL;
  1114. ((((T56*)(((T56*)(oBC359header_comment_memory)))))->_item)=(_default_item);
  1115. }/*]*/
  1116. r605collect_for(((T605*)(X291base_class(/*X496*/((T0*)(((T808*)((T808*)a1)))->_current_type/*4*/)))),1002,/*X496*/((T0*)(((T808*)((T808*)a1)))->_name/*16*/));
  1117. _r=r134runnable(oBC359assertion_collector,/*X496*/((T0*)(((T808*)((T808*)a1)))->_current_type/*4*/),a1);
  1118. /*IF*/if ((_r)!=((void*)(NULL))) {
  1119. {T633*n=malloc(sizeof(*n));
  1120. *n=M633;
  1121. r633from_runnable(n,_r);
  1122. R=(T0*)n;
  1123. }
  1124. /*[IRF3.3set_header_comment*/((((T633*)(((T633*)R))))->_header_comment)=((((T56*)((T56*)(oBC359header_comment_memory))))->_item/*0*/);
  1125. /*]*/
  1126. /*[IRF3.3clear*/{T0* _default_item=NULL;
  1127. ((((T56*)(((T56*)(oBC359header_comment_memory)))))->_item)=(_default_item);
  1128. }/*]*/
  1129. }
  1130. /*FI*/return R;
  1131. }
  1132. T0* r134run_require(T0* a1){
  1133. T0* R=NULL;
  1134. T0* _ar=NULL;
  1135. T0* _hc=NULL;
  1136. T0* _er=NULL;
  1137. T0* _r=NULL;
  1138. int _i=0;
  1139. r522clear(((T522*)(oBC359require_collector)));
  1140. r605collect_for(((T605*)(X291base_class(/*X496*/((T0*)(((T808*)((T808*)a1)))->_current_type/*4*/)))),1001,/*X496*/((T0*)(((T808*)((T808*)a1)))->_name/*16*/));
  1141. /*IF*/if (!(r522empty(((T522*)(oBC359require_collector))))) {
  1142. _i=1;
  1143. while (!((_i)>((((T522*)((T522*)(oBC359require_collector))))->_upper/*8*/))) {
  1144. _er=r522item(((T522*)(oBC359require_collector)),_i);
  1145. _hc=(((T343*)((T343*)_er)))->_header_comment/*4*/;
  1146. /*IF*/if (!(/*(IRF4.7empty*/((((T343*)((T343*)_er)))->_list/*8*/)==(NULL)/*)*/)) {
  1147. _r=r134runnable((((T343*)((T343*)_er)))->_list/*8*/,/*X496*/((T0*)(((T808*)((T808*)a1)))->_current_type/*4*/),a1);
  1148. /*IF*/if ((_r)!=((void*)(NULL))) {
  1149. {T343*n=malloc(sizeof(*n));
  1150. *n=M343;
  1151. r343from_runnable(n,_r);
  1152. _er=(T0*)n;
  1153. }
  1154. /*[IRF3.3set_header_comment*/((((T343*)(((T343*)_er))))->_header_comment)=(_hc);
  1155. /*]*/
  1156. /*IF*/if ((_ar)==((void*)(NULL))) {
  1157. _ar=se_ma522(1,_er);
  1158. }
  1159. else {
  1160. r522add_last(((T522*)_ar),_er);
  1161. }
  1162. /*FI*/}
  1163. /*FI*/}
  1164. /*FI*/_i=(_i)+(1);
  1165. }
  1166. /*IF*/if ((_ar)!=((void*)(NULL))) {
  1167. {T541*n=malloc(sizeof(*n));
  1168. *n=M541;
  1169. /*[IRF3.3make*/((((T541*)(n)))->_list)=(_ar);
  1170. /*]*/
  1171. R=(T0*)n;
  1172. }
  1173. }
  1174. /*FI*/}
  1175. /*FI*/return R;
  1176. }
  1177. /*No:ONCE_PROCEDURE.result_type*/
  1178. /*No:ONCE_PROCEDURE.fz_03*/
  1179. /*No:ONCE_PROCEDURE.em1*/
  1180. /*No:ONCE_PROCEDURE.obsolete_mark*/
  1181. /*No:ONCE_PROCEDURE.set_clients*/
  1182. /*No:ONCE_PROCEDURE.em2*/
  1183. /*No:ONCE_PROCEDURE.names*/
  1184. /*No:ONCE_PROCEDURE.require_assertion*/
  1185. /*No:ONCE_PROCEDURE.use_current_state*/
  1186. /*No:ONCE_PROCEDURE.code_ensure*/
  1187. void r134set_rescue_compound(T134* C,T0* a1){
  1188. /*IF*/if (((a1)!=((void*)(NULL)))&&(/*(IRF4.1is_deferred*/0/*)*/)) {
  1189. r134error(r134start_position(C),((T0*)ms6_355));
  1190. }
  1191. /*FI*/C->_rescue_compound=a1;
  1192. }
  1193. int r134can_hide(T134* C,T0* a1,T0* a2){
  1194. int R=0;
  1195. /*IF*/if (((((T134*)C))->_result_type/*12*/)!=((void*)(/*X359*/((T0*)(((T398*)((T398*)a1)))->_result_type/*12*/)))) {
  1196. /*IF*/if ((((((T134*)C))->_result_type/*12*/)==((void*)(NULL)))||((/*X359*/((T0*)(((T398*)((T398*)a1)))->_result_type/*12*/))==((void*)(NULL)))) {
  1197. r683add_position(X359start_position(a1));
  1198. r134error(r134start_position(C),((T0*)ms5_359));
  1199. }
  1200. /*FI*/}
  1201. /*FI*//*IF*/if (((((T134*)C))->_arguments/*28*/)!=((void*)(X359arguments(a1)))) {
  1202. /*IF*/if ((((((T134*)C))->_arguments/*28*/)==((void*)(NULL)))||((X359arguments(a1))==((void*)(NULL)))) {
  1203. r683add_position(X359start_position(a1));
  1204. r134error(r134start_position(C),((T0*)ms6_359));
  1205. }
  1206.  else if ((/*(IRF4.6count*/(((T65*)((T65*)((((T31*)((T31*)((((T134*)C))->_arguments/*28*/))))->_flat_list/*12*/))))->_upper/*12*//*)*/)!=(/*(IRF4.6count*/(((T65*)((T65*)((((T31*)((T31*)(X359arguments(a1)))))->_flat_list/*12*/))))->_upper/*12*//*)*/)) {
  1207. r683add_position(X359start_position(a1));
  1208. r134error(r134start_position(C),((T0*)ms7_359));
  1209. }
  1210. /*FI*/}
  1211. /*FI*//*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0)) {
  1212. /*IF*/if (((((T134*)C))->_result_type/*12*/)!=((void*)(NULL))) {
  1213. /*IF*/if (!(X291is_a_in((((T134*)C))->_result_type/*12*/,/*X359*/((T0*)(((T398*)((T398*)a1)))->_result_type/*12*/),a2))) {
  1214. /*[IRF3.6append*/{T0* b1=((T0*)ms13_359);
  1215. r7append(((T7*)(oBC683explanation)),b1);
  1216. }/*]*/
  1217. /*[IRF3.6append*/{T0* b1=X291run_time_mark((((T368*)((T368*)a2)))->_current_type/*0*/);
  1218. r7append(((T7*)(oBC683explanation)),b1);
  1219. }/*]*/
  1220. r683error(((T683*)(oBC364eh)),((T0*)ms67_470));
  1221. }
  1222. /*FI*/}
  1223. /*FI*/}
  1224. /*FI*//*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0)) {
  1225. /*IF*/if (((((T134*)C))->_arguments/*28*/)!=((void*)(NULL))) {
  1226. /*IF*/if (!(r31is_a_in(((T31*)((((T134*)C))->_arguments/*28*/)),X359arguments(a1),a2))) {
  1227. r683add_position(X359start_position(a1));
  1228. r683add_position(r134start_position(C));
  1229. /*[IRF3.6append*/{T0* b1=((T0*)ms13_359);
  1230. r7append(((T7*)(oBC683explanation)),b1);
  1231. }/*]*/
  1232. /*[IRF3.6append*/{T0* b1=X291run_time_mark((((T368*)((T368*)a2)))->_current_type/*0*/);
  1233. r7append(((T7*)(oBC683explanation)),b1);
  1234. }/*]*/
  1235. r683error(((T683*)(oBC364eh)),((T0*)ms67_470));
  1236. }
  1237. /*FI*/}
  1238. /*FI*/}
  1239. /*FI*/R=(/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0);
  1240. return R;
  1241. }
  1242. /*No:ONCE_PROCEDURE.header_comment*/
  1243. /*No:ONCE_PROCEDURE.routine_body*/
  1244. int r134is_merge_with(T134* C,T0* a1,T0* a2){
  1245. int R=0;
  1246. /*IF*/if (((((T134*)C))->_result_type/*12*/)!=((void*)(/*X359*/((T0*)(((T398*)((T398*)a1)))->_result_type/*12*/)))) {
  1247. /*IF*/if ((((((T134*)C))->_result_type/*12*/)==((void*)(NULL)))||((/*X359*/((T0*)(((T398*)((T398*)a1)))->_result_type/*12*/))==((void*)(NULL)))) {
  1248. r683add_position(X359start_position(a1));
  1249. r134error(r134start_position(C),((T0*)ms2_359));
  1250. }
  1251. /*FI*/}
  1252. /*FI*//*IF*/if (((((T134*)C))->_arguments/*28*/)!=((void*)(X359arguments(a1)))) {
  1253. /*IF*/if ((((((T134*)C))->_arguments/*28*/)==((void*)(NULL)))||((X359arguments(a1))==((void*)(NULL)))) {
  1254. r683add_position(X359start_position(a1));
  1255. r134error(r134start_position(C),((T0*)ms3_359));
  1256. }
  1257.  else if ((/*(IRF4.6count*/(((T65*)((T65*)((((T31*)((T31*)((((T134*)C))->_arguments/*28*/))))->_flat_list/*12*/))))->_upper/*12*//*)*/)!=(/*(IRF4.6count*/(((T65*)((T65*)((((T31*)((T31*)(X359arguments(a1)))))->_flat_list/*12*/))))->_upper/*12*//*)*/)) {
  1258. r683add_position(X359start_position(a1));
  1259. r134error(r134start_position(C),((T0*)ms4_359));
  1260. }
  1261. /*FI*/}
  1262. /*FI*//*IF*/if (((((T134*)C))->_result_type/*12*/)!=((void*)(NULL))) {
  1263. /*IF*/if (!(X291is_a_in((((T134*)C))->_result_type/*12*/,/*X359*/((T0*)(((T398*)((T398*)a1)))->_result_type/*12*/),a2))) {
  1264. r683error(((T683*)(oBC364eh)),((T0*)ms12_359));
  1265. }
  1266. /*FI*/}
  1267. /*FI*//*IF*/if (((((T134*)C))->_arguments/*28*/)!=((void*)(NULL))) {
  1268. /*IF*/if (!(r31is_a_in(((T31*)((((T134*)C))->_arguments/*28*/)),X359arguments(a1),a2))) {
  1269. r683add_position(X359start_position(a1));
  1270. r134error(r134start_position(C),((T0*)ms12_359));
  1271. }
  1272. /*FI*/}
  1273. /*FI*/R=(/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0);
  1274. return R;
  1275. }
  1276. /*No:ONCE_PROCEDURE.fz_dot*/
  1277. /*No:ONCE_PROCEDURE.set_ensure_assertion*/
  1278. /*No:ONCE_PROCEDURE.first_name*/
  1279. /*No:ONCE_PROCEDURE.clients*/
  1280. void r134collect_for(T134* C,int a1){
  1281. /*IF*/if ((a1)==(1001)) {
  1282. /*IF*/if (((((T134*)C))->_require_assertion/*36*/)!=((void*)(NULL))) {
  1283. /*IF*/if (!(r522fast_has(((T522*)(oBC359require_collector)),(((T134*)C))->_require_assertion/*36*/))) {
  1284. r522add_last(((T522*)(oBC359require_collector)),(((T134*)C))->_require_assertion/*36*/);
  1285. }
  1286. /*FI*/}
  1287. /*FI*/}
  1288. else {
  1289. /*IF*/if (((((T134*)C))->_ensure_assertion/*40*/)!=((void*)(NULL))) {
  1290. /*[IRF3.3set_item*/((((T56*)(((T56*)(oBC359header_comment_memory)))))->_item)=((((T633*)((T633*)((((T134*)C))->_ensure_assertion/*40*/))))->_header_comment/*4*/);
  1291. /*]*/
  1292. r633add_into(((T633*)((((T134*)C))->_ensure_assertion/*40*/)),oBC359assertion_collector);
  1293. }
  1294. /*FI*/}
  1295. /*FI*/}
  1296. void r134error(T0* a1,T0* a2){
  1297. r683add_position(a1);
  1298. r683error(((T683*)(oBC364eh)),a2);
  1299. }
  1300. /*No:ONCE_PROCEDURE.base_class*/
  1301. T0*oBC359require_collector=NULL;
  1302. void r134make_e_feature(T134* C,T0* a1,T0* a2){
  1303. C->_names=a1;
  1304. C->_result_type=a2;
  1305. }
  1306. void r134check_obsolete(T134* C){
  1307. /*IF*/if (!((((T604*)((T604*)(oBC364small_eiffel))))->_short_flag/*4*/)) {
  1308. /*IF*/if (((((T134*)C))->_obsolete_mark/*32*/)!=((void*)(NULL))) {
  1309. /*[IRF3.6append*/{T0* b1=((T0*)ms7_355);
  1310. r7append(((T7*)(oBC683explanation)),b1);
  1311. }/*]*/
  1312. /*[IRF3.6append*/{T0* b1=(((T805*)((T805*)((((T134*)C))->_obsolete_mark/*32*/))))->_to_string/*12*/;
  1313. r7append(((T7*)(oBC683explanation)),b1);
  1314. }/*]*/
  1315. r134warning(r134start_position(C),((T0*)ms137_470));
  1316. }
  1317. /*FI*/}
  1318. /*FI*/}
  1319. void r134warning(T0* a1,T0* a2){
  1320. r683add_position(a1);
  1321. r683warning(((T683*)(oBC364eh)),a2);
  1322. }
  1323. /*No:RUN_FEATURE_6.arguments*/
  1324. T0*oBC364run_control=NULL;
  1325. /*No:RUN_FEATURE_6.actuals_clients*/
  1326. void r868make(T868* C,T0* a1,T0* a2,T0* a3){
  1327. C->_current_type=a1;
  1328. C->_name=a2;
  1329. C->_base_feature=a3;
  1330. r199put(((T199*)((((T368*)((T368*)(r868run_class(C)))))->_feature_dictionary/*24*/)),(T0*)C,X776to_key(a2));
  1331. r604incr_magic_count(((T604*)(oBC364small_eiffel)));
  1332. C->_use_current_state=1015;
  1333. r604push(((T604*)(oBC364small_eiffel)),(T0*)C);
  1334. r868initialize(C);
  1335. r604pop(((T604*)(oBC364small_eiffel)));
  1336. }
  1337. /*No:RUN_FEATURE_6.name*/
  1338. int r868arg_count(T868* C){
  1339. int R=0;
  1340. /*IF*/if (((((T868*)C))->_arguments/*20*/)!=((void*)(NULL))) {
  1341. R=/*(IRF4.6count*/(((T65*)((T65*)((((T31*)((T31*)((((T868*)C))->_arguments/*20*/))))->_flat_list/*12*/))))->_upper/*12*//*)*/;
  1342. }
  1343. /*FI*/return R;
  1344. }
  1345. /*No:RUN_FEATURE_6.local_vars*/
  1346. /*No:RUN_FEATURE_6.base_feature*/
  1347. /*No:RUN_FEATURE_6.start_position*/
  1348. /*No:RUN_FEATURE_6.ensure_assertion*/
  1349. int r868is_exported_in(T868* C,T0* a1){
  1350. int R=0;
  1351. R=r636gives_permission_to(((T636*)(r868clients(C))),a1);
  1352. return R;
  1353. }
  1354. /*No:RUN_FEATURE_6.result_type*/
  1355. T0*oBC364once_routine_pool=NULL;
  1356. void r868add_client(T868* C,T0* a1){
  1357. int _i=0;
  1358. /*IF*/if (((((T868*)C))->_actuals_clients/*12*/)==((void*)(NULL))) {
  1359. {T187*n=malloc(sizeof(*n));
  1360. *n=M187;
  1361. r187with_capacity(n,4);
  1362. C->_actuals_clients=(T0*)n;
  1363. }
  1364. r187add_last(((T187*)((((T868*)C))->_actuals_clients/*12*/)),a1);
  1365. }
  1366. else {
  1367. _i=r187fast_index_of(((T187*)((((T868*)C))->_actuals_clients/*12*/)),a1);
  1368. /*IF*/if ((_i)>((((T187*)((T187*)((((T868*)C))->_actuals_clients/*12*/))))->_upper/*8*/)) {
  1369. r187add_last(((T187*)((((T868*)C))->_actuals_clients/*12*/)),a1);
  1370. }
  1371. /*FI*/}
  1372. /*FI*/r368add_client(((T368*)(r868run_class(C))),a1);
  1373. }
  1374. /*No:RUN_FEATURE_6.require_assertion*/
  1375. /*No:RUN_FEATURE_6.use_current_state*/
  1376. /*No:RUN_FEATURE_6.current_type*/
  1377. T0* r868run_class(T868* C){
  1378. T0* R=NULL;
  1379. R=X291run_class((((T868*)C))->_current_type/*4*/);
  1380. return R;
  1381. }
  1382. /*No:RUN_FEATURE_6.ucs_not_computed*/
  1383. /*No:RUN_FEATURE_6.routine_body*/
  1384. T0* r868clients(T868* C){
  1385. T0* R=NULL;
  1386. T0* _bfbc=NULL;
  1387. T0* _bc=NULL;
  1388. /*IF*/if (((((T868*)C))->_clients_memory/*8*/)==((void*)(NULL))) {
  1389. _bc=X291base_class((((T868*)C))->_current_type/*4*/);
  1390. _bfbc=(((T844*)((T844*)((((T868*)C))->_base_feature/*44*/))))->_base_class/*4*/;
  1391. /*IF*/if ((_bc)==((void*)(_bfbc))) {
  1392. R=(((T844*)((T844*)((((T868*)C))->_base_feature/*44*/))))->_clients/*24*/;
  1393. }
  1394. else {
  1395. R=r605clients_for(((T605*)_bc),(((T868*)C))->_name/*16*/);
  1396. }
  1397. /*FI*/C->_clients_memory=R;
  1398. }
  1399. else {
  1400. R=(((T868*)C))->_clients_memory/*8*/;
  1401. }
  1402. /*FI*/return R;
  1403. }
  1404. /*No:RUN_FEATURE_6.fatal_error*/
  1405. /*No:RUN_FEATURE_6.clients_memory*/
  1406. void r868initialize(T868* C){
  1407. C->_arguments=(((T844*)((T844*)((((T868*)C))->_base_feature/*44*/))))->_arguments/*28*/;
  1408. /*IF*/if ((((((T868*)C))->_arguments/*20*/)!=((void*)(NULL)))&&((/*(IRF4.6count*/(((T65*)((T65*)((((T31*)((T31*)((((T868*)C))->_arguments/*20*/))))->_flat_list/*12*/))))->_upper/*12*//*)*/)>(0))) {
  1409. C->_arguments=r31to_runnable(((T31*)((((T868*)C))->_arguments/*20*/)),(((T868*)C))->_current_type/*4*/);
  1410. }
  1411. /*FI*/C->_result_type=(((T844*)((T844*)((((T868*)C))->_base_feature/*44*/))))->_result_type/*12*/;
  1412. /*IF*/if (X291is_anchored((((T868*)C))->_result_type/*24*/)) {
  1413. r683add_position(X291start_position((((T868*)C))->_result_type/*24*/));
  1414. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms7_868);
  1415. r683fatal_error(((T683*)(oBC364eh)),b1);
  1416. }/*]*/
  1417. }
  1418.  else if (X291is_formal_generic((((T868*)C))->_result_type/*24*/)) {
  1419. r683add_position(X291start_position((((T868*)C))->_result_type/*24*/));
  1420. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms8_868);
  1421. r683fatal_error(((T683*)(oBC364eh)),b1);
  1422. }/*]*/
  1423. }
  1424. /*FI*/C->_result_type=X291to_runnable((((T868*)C))->_result_type/*24*/,(((T868*)C))->_current_type/*4*/);
  1425. C->_local_vars=(((T844*)((T844*)((((T868*)C))->_base_feature/*44*/))))->_local_vars/*20*/;
  1426. /*IF*/if ((((((T868*)C))->_local_vars/*48*/)!=((void*)(NULL)))&&((/*(IRF4.6count*/(((T733*)((T733*)((((T620*)((T620*)((((T868*)C))->_local_vars/*48*/))))->_flat_list/*12*/))))->_upper/*12*//*)*/)>(0))) {
  1427. C->_local_vars=r620to_runnable(((T620*)((((T868*)C))->_local_vars/*48*/)),(((T868*)C))->_current_type/*4*/);
  1428. }
  1429. /*FI*/C->_routine_body=(((T844*)((T844*)((((T868*)C))->_base_feature/*44*/))))->_routine_body/*52*/;
  1430. /*IF*/if (((((T868*)C))->_routine_body/*32*/)!=((void*)(NULL))) {
  1431. C->_routine_body=r592to_runnable(((T592*)((((T868*)C))->_routine_body/*32*/)),(((T868*)C))->_current_type/*4*/);
  1432. }
  1433. /*FI*//*IF*/if (r590require_check(((T590*)(oBC364run_control)))) {
  1434. C->_require_assertion=r844run_require((T0*)C);
  1435. }
  1436. /*FI*//*IF*/if (r590ensure_check(((T590*)(oBC364run_control)))) {
  1437. C->_ensure_assertion=r844run_ensure((T0*)C);
  1438. }
  1439. /*FI*/r916add_function((T0*)C);
  1440. }
  1441.  
  1442.